package org.aplombh.java.awcing.basic.graph.minimumSpanningTree.prim;


import java.util.Arrays;
import java.util.Scanner;

/**
 * 给定一个 n 个点 m 条边的无向图，图中可能存在重边和自环，边权可能为负数。
 * <p>
 * 求最小生成树的树边权重之和，如果最小生成树不存在则输出 impossible。
 * <p>
 * 给定一张边带权的无向图 G=(V,E)，其中 V 表示图中点的集合，E 表示图中边的集合，n=|V|，m=|E|。
 * <p>
 * 由 V 中的全部 n 个顶点和 E 中 n−1 条边构成的无向连通子图被称为 G 的一棵生成树，其中边的权值之和最小的生成树被称为无向图 G 的最小生成树。
 * <p>
 * 输入格式
 * 第一行包含两个整数 n 和 m。
 * <p>
 * 接下来 m 行，每行包含三个整数 u,v,w，表示点 u 和点 v 之间存在一条权值为 w 的边。
 * <p>
 * 输出格式
 * 共一行，若存在最小生成树，则输出一个整数，表示最小生成树的树边权重之和，如果最小生成树不存在则输出 impossible。
 * <p>
 * 数据范围
 * 1≤n≤500,
 * 1≤m≤105,
 * 图中涉及边的边权的绝对值均不超过 10000。
 * <p>
 * 输入样例：
 * 4 5
 * 1 2 1
 * 1 3 2
 * 1 4 3
 * 2 3 2
 * 3 4 4
 * 输出样例：
 * 6
 */
public class Prim_858 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        Prim prim = new Prim(n);
        while (m-- != 0) {
            int a = scanner.nextInt();
            int b = scanner.nextInt();
            int c = scanner.nextInt();
            prim.g[a][b] = prim.g[b][a] = Math.min(prim.g[a][b], c);
        }
        int t = prim.prim();
        if (t == 1 << 30)
            System.out.println("impossible");
        System.out.println(t);
    }
}

class Prim {
    public static final int N = 510;
    int[][] g = new int[N][N]; // 存储图 Store the graph
    int[] dist = new int[N]; // 到集合中某点的最短距离 The distance to some point int the set
    boolean[] st = new boolean[N]; // 是否访问过  visited
    int n;

    Prim(int n) {
        init(n);
    }

    void init(int n) {
        this.n = n;
        // 初始化 initialize
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                if (i == j) g[i][j] = 0;
                else g[i][j] = 1 << 30;
            }
        }
        Arrays.fill(dist, 1 << 30);
        dist[1] = 0;
    }

    public int prim() {

        // res 权重之和 The sum of the weights
        int res = 0;
        // 进行n次循环，每次找到未访问的距离最短的一个点 Do n loops, each time finding the point int the set with the shortest unvisited distance
        for (int i = 0; i < n; i++) {
            // 最短边连接的点 The point at which the shortest edge is connected
            int t = -1;
            // 找到最短的那条边连接的点 Find the point where the shortest edge connects
            for (int j = 1; j <= n; j++) {
                // 如果当前点未访问过并且它的最短路径比dist[t]短，则给t赋值为当前点 If the current point is unvisited and its shortest path is shorter than dist[t], then t is assigned to the current point
                if (!st[j] && (t == -1 || dist[t] > dist[j])) {
                    t = j;
                }
            }

            // 不连通 disconnected graph
            if (dist[t] == 1 << 30) return 1 << 30;

            // 权重计算 calculate the sum of the weights
            res += dist[t];

            // 标记已访问 Mark accessed
            st[t] = true;

            // 更新到集合的距离 Update the distance to the set
            for (int j = 1; j <= n; j++) dist[j] = Math.min(dist[j], g[t][j]);
        }
        return res;
    }
}